﻿/*
 				________________________________COPYRIGHT_______________________________________
				Die Veröffentlichung dieses Objektes ist Illegal und wird strafrechtlich verfolgt
				werden. Sollte es zu einer Veröffentlichung kommen werden wir die Daten des
				Herrausgebers fündig machen und Anzeige erstatten. Desweiteren ist
				auch jeglicher Besitz dieses Objektes Illegal und kann ebenfalls als Grund für
				eine Anzeige verwendet werden.
				Ausnahmen der veröffentlichung und verleihung gelten nur wenn der Grundbesitzer
				diese durchführt.
				Die Uhrheberrechte dieses Objektes liegen der Entwickler Gruppe CyberScripting vor. 
                © 2011.
 */


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;

namespace cubeworld.World
{
    // diese Klasse beschreibt, in welchen chunk sich der spieler befindet, und wann ein neuer chunk generiert werden soll

    delegate void ChunkChanged(object sender, EventArgs args, Chunk newChunk);

    class ChunkManager
    {
        public event ChunkChanged onChunkChanged;

        World w;

        Vector2 oldChunk = new Vector2();
        public Vector2 newChunk;

        public Point camera;

        public ChunkManager(World w)
        {
            this.w = w;
        }

        public void Update(List<Chunk> activeChunks)
        {
            Vector2 camPos = new Vector2(Data.camera.Position.X, Data.camera.Position.Z);


            newChunk = new Vector2(r((int)camPos.X), r((int)camPos.Y));

            if (newChunk.X <= 0.0f && camPos.X < 0.0f)
                newChunk.X -= 1;
            if (newChunk.Y <= 0.0f && camPos.Y < 0.0f)
                newChunk.Y -= 1;

            if (oldChunk != newChunk && onChunkChanged != null)
                onChunkChanged(this, EventArgs.Empty, getCurrentChunk(activeChunks));
            oldChunk = newChunk;
            
            if(Data.isDebugMode)
                Data.spriteBatch.DrawString(Data.debugFont, newChunk.ToString(), new Vector2(300, 300), Color.White);
        }

        public Chunk getCurrentChunk(List<Chunk> activeChunks)
        {
            foreach (Chunk c in activeChunks)
            {
                if (newChunk.X * 16 == c.StartX && newChunk.Y * 16 == c.StartZ)
                    return c;
            }
            return null;
        }

        public void setCheckableChunks()
        {
            Data.world.checkableChunks = new List<Chunk>();
            foreach (Chunk c in Data.world.activeChunks)
            {
                if (c.StartX == newChunk.X * 16 && c.StartZ == newChunk.Y * 16) //1
                {
                    Data.world.checkableChunks.Add(c);
                }

                if (c.StartX == (newChunk.X - 1) * 16 && c.StartZ == newChunk.Y * 16) //2
                {
                    Data.world.checkableChunks.Add(c);
                }

                if (c.StartX == (newChunk.X + 1) * 16 && c.StartZ == newChunk.Y * 16) //3
                {
                    Data.world.checkableChunks.Add(c);
                }

                if (c.StartX == newChunk.X * 16 && c.StartZ == (newChunk.Y - 1) * 16) //4
                {
                    Data.world.checkableChunks.Add(c);
                }

                if (c.StartX == newChunk.X * 16 && c.StartZ == (newChunk.Y + 1) * 16) //5
                {
                    Data.world.checkableChunks.Add(c);
                }

                if (c.StartX == (newChunk.X - 1) * 16 && c.StartZ == (newChunk.Y - 1) * 16) //6
                {
                    Data.world.checkableChunks.Add(c);
                }

                if (c.StartX == (newChunk.X + 1) * 16 && c.StartZ == (newChunk.Y - 1) * 16) //7
                {
                    Data.world.checkableChunks.Add(c);
                }

                if (c.StartX == (newChunk.X + 1) * 16 && c.StartZ == (newChunk.Y + 1) * 16) //8
                {
                    Data.world.checkableChunks.Add(c);
                }

                if (c.StartX == (newChunk.X - 1) * 16 && c.StartZ == (newChunk.Y + 1) * 16) //9
                {
                    Data.world.checkableChunks.Add(c);
                }
            }
        }

        private int r(int zahl)
        {
            int get = (int)(zahl / 16); 
            return get;
        }

        public bool existsChunkAtStart(int StartX, int StartZ, List<Chunk> activeChunks)
        {
            foreach (Chunk c in activeChunks)
            {
                if (c.StartX == StartX && c.StartZ == StartZ)
                {
                    return true;
                }
            }

            return false;
        }

        public List<Block> getVisibleBlocks(List<Chunk> activeChunks)
        {
            List<Block> bList = new List<Block>();

            foreach (Chunk c in activeChunks)
            {
                foreach (Block b in c.Blocks)
                {
                    if (b.visible)
                        bList.Add(b);
                }
            }

            return bList;
        }
    }
}
